home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Texteditors / Origami / Sources / src / lib / refdecomp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-27  |  3.3 KB  |  150 lines
  1. /*{{{}}}*/
  2. /*{{{  includes*/
  3. #include <stdio.h>
  4. #include <unistd.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  7. #include <ctype.h>
  8.  
  9. #include <h/keys.h>
  10. #include <h/token.h>
  11. #include <h/rcformat.h>
  12. #include <lib/ori_rc_lib.h>
  13. #include <lib/ori_add_lib.h>
  14. /*}}}  */
  15.  
  16. /*{{{  variables*/
  17. static int ref_word_count=0;
  18. static char *ref_word_list=0;
  19. /*}}}  */
  20.  
  21. /*{{{  ref_uncompress_text*/
  22. void ref_uncompress_text(char const *source,char *dest)
  23. { char const *ubp;
  24.   char *b;
  25.  
  26.   if (ref_word_list)
  27.      for (ubp=source,b=dest;;)
  28.       { char c;
  29.  
  30.         switch((c = *ubp++))
  31.          { int l;
  32.      
  33.            /*{{{  special coded word*/
  34.            case REF_CODE_LWORD:
  35.            case REF_CODE_UWORD:
  36.             { int id;
  37.  
  38.               id=((unsigned char)*ubp++)-REF_COUNT_BASE;
  39.               /*{{{  append word*/
  40.               if (id<ref_word_count && ref_word_list)
  41.                { char *w;
  42.  
  43.                  for (w=ref_word_list;id>0;id--)
  44.                     while (*w++);
  45.                  if (c==REF_CODE_UWORD)
  46.                   { char c;
  47.  
  48.                     c= *w++;
  49.                     *b++=toupper(c);
  50.                   }
  51.                  while ((*b = *w++))
  52.                     b++;
  53.                }
  54.               else
  55.                  *b='\0';
  56.               /*}}}  */
  57.               continue;
  58.             }
  59.            /*}}}  */
  60.            /*{{{  space sequence*/
  61.            case REF_CODE_SPACES:
  62.               c=' ';
  63.               goto seq_gen;
  64.            /*}}}  */
  65.            /*{{{  char sequence*/
  66.            case REF_CODE_CHARS:
  67.               c = *ubp++;
  68.               goto seq_gen;
  69.            /*}}}  */
  70.            /*{{{  ctrl*/
  71.            case REF_CODE_C:
  72.               *b++='C';
  73.               *b++='-';
  74.               continue;
  75.            /*}}}  */
  76.            /*{{{  meta*/
  77.            case REF_CODE_M:
  78.               *b++='M';
  79.               *b++='-';
  80.               continue;
  81.            /*}}}  */
  82.            /*{{{  single char*/
  83.            default:
  84.               l=1;
  85.               goto seq_loop;
  86.            /*}}}  */
  87.            /*{{{  decode the sequences*/
  88.            seq_gen:
  89.               l = *ubp++-REF_COUNT_BASE;
  90.               goto seq_loop;
  91.            seq_loop:
  92.               for (;l-->0;*b++=c);
  93.               continue;
  94.            /*}}}  */
  95.            /*{{{  0=eol*/
  96.            case '\0':
  97.               *b='\0';
  98.               break;
  99.            /*}}}  */
  100.          }
  101.         break;
  102.       }
  103. }
  104. /*}}}  */
  105. /*{{{  ref_free_comp_data*/
  106. void ref_free_comp_data(void)
  107. {
  108.   if (ref_word_list)
  109.    { ORIfree(ref_word_list);
  110.      ref_word_list=0;
  111.      ref_word_count=0;
  112.    }
  113. }
  114. /*}}}  */
  115. /*{{{  ref_read_comp_data*/
  116. char *ref_read_comp_data(FILE * const f)
  117. {
  118.   int l;
  119.   char *s;
  120.  
  121.   ref_free_comp_data();
  122.   if ((l=rc_get_w(f)))
  123.      if ((ref_word_list=ORImalloc(l+1)))
  124.       /*{{{  read all patterns*/
  125.       { rc_nget_c(f,l,ref_word_list);
  126.         for (s=ref_word_list;;)
  127.            if (--l==0)
  128.             /*{{{  list handled, so break*/
  129.             {
  130.               if (*s!='\0')
  131.                  ref_free_comp_data();
  132.               else
  133.                  ref_word_count++;
  134.               break;
  135.             }
  136.             /*}}}  */
  137.            else if (*s++=='\0')
  138.             /*{{{  count the word*/
  139.               ref_word_count++;
  140.             /*}}}  */
  141.         s[1]='\0';
  142.       }
  143.       /*}}}  */
  144.      else
  145.         rc_skip_cw(f,l,0);
  146.  
  147.   return(ref_word_list);
  148. }
  149. /*}}}  */
  150.